package com.zenithmind.user.controller;

import com.zenithmind.common.annotation.Log;
import com.zenithmind.common.constant.OperationTypeEnum;
import com.zenithmind.user.enums.VerificationCodeType;
import com.zenithmind.user.pojo.dto.RegisterDTO;
import com.zenithmind.user.pojo.dto.VerificationRequestDTO;
import com.zenithmind.user.pojo.domain.User;
import com.zenithmind.user.pojo.domain.UserRole;
import com.zenithmind.user.pojo.dto.LoginDTO;
import com.zenithmind.user.pojo.dto.SimpleLoginDTO;
import com.zenithmind.user.pojo.dto.UserProfileUpdateDTO;
import com.zenithmind.user.pojo.query.UserQuery;
import com.zenithmind.user.pojo.vo.UserVO;
import com.zenithmind.common.result.PageResult;
import com.zenithmind.common.result.Result;
import com.zenithmind.common.result.ResultCode;
import com.zenithmind.user.service.UserService;
import com.zenithmind.user.service.VerificationCodeService;
import io.swagger.v3.oas.annotations.Operation;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import com.zenithmind.user.pojo.dto.AdminLoginDTO;

import lombok.extern.slf4j.Slf4j;

import java.util.List;


/**
 * 用户控制器门面
 * 遵循开闭原则：保持向后兼容性，同时委托给专门的控制器
 * 遵循单一职责原则：作为门面统一对外提供接口
 *
 * @deprecated 建议使用专门的控制器：
 * - AuthenticationController: 认证相关
 * - UserQueryController: 查询相关
 * - UserManagementController: 管理相关
 */
@Slf4j
@RestController
@RequestMapping("/api/zenithMind/user")
@Tag(name = "用户管理", description = "用户管理门面接口（兼容性保留）")
@Deprecated
public class UserController {
    @Autowired
    private UserService userService;

    @Autowired
    private VerificationCodeService verificationCodeService;

    @Autowired
    private UserManagementController userManagementController;

    @Log(description = "添加或修改用户信息", operationType = OperationTypeEnum.UPDATE)
    @PostMapping("/addOrUpdateUser")
    @Operation(summary = "用户添加或修改-管理员")
    public Result<UserVO> addOrUpdateUser(@RequestBody User user) {
          UserVO userVO =  userService.addOrUpdateUser(user);
        return Result.success(userVO);
    }

    /**
     * 用户登录接口 (需要验证码)
     *
     * @param loginDTO 包含用户登录信息和验证码的DTO
     * @return 登录结果，包含用户信息
     */
    @Log(description = "用户登录", operationType = OperationTypeEnum.LOGIN)
    @PostMapping("/loginUser")
    @Operation(summary = "用户登录 (需要验证码)")
    public Result<UserVO> login(@Valid @RequestBody LoginDTO loginDTO) {
        log.info("用户登录：{}", loginDTO);
        return userService.login(loginDTO);
    }

    /**
     * 管理员登录接口 (需要验证码)
     *
     * @param adminLoginDTO 包含管理员登录信息和验证码的DTO
     * @return 登录结果，包含用户信息
     */
    @Log(description = "管理员登录", operationType = OperationTypeEnum.LOGIN)
    @PostMapping("/loginAdmin")
    @Operation(summary = "管理员登录 (需要验证码)")
    public Result<UserVO> adminLogin(@Valid @RequestBody AdminLoginDTO adminLoginDTO) {
        return userService.adminLogin(adminLoginDTO);
    }

    /**
     * 简单用户登录接口 (仅用于测试，不需要验证码)
     *
     * @param simpleLoginDTO 包含用户名和密码的简单登录DTO
     * @return 登录结果，包含用户信息
     */
    @Log(description = "简单用户登录", operationType = OperationTypeEnum.LOGIN)
    @PostMapping("/simpleLogin")
    @Operation(summary = "简单用户登录 (测试用，不需要验证码)")
    public Result<UserVO> simpleLogin(@RequestBody SimpleLoginDTO simpleLoginDTO) {
        log.info("简单用户登录：{}", simpleLoginDTO.getUsername());
        return userService.simpleLogin(simpleLoginDTO);
    }

    /**
     * 用户登出接口
     *
     * @return 登出结果，成功退出的消息
     */
    @Log(description = "用户登出", operationType = OperationTypeEnum.LOGOUT)
    @GetMapping("/logoutUser")
    @Operation(summary = "用户登出")
    public Result<String> logout() {
        return Result.success("成功退出");
    }

    /**
     * 用户注册接口 (需要邮箱验证码)
     *
     * @param registerDTO 用户注册信息，包含邮箱验证码
     * @return 注册结果，包含用户信息
     */
    @Log(description = "用户注册", operationType = OperationTypeEnum.ADD)
    @Operation(summary = "用户注册 (需要邮箱验证码)")
    @PostMapping("/registerUser")
    public Result<UserVO> register(@Valid @RequestBody RegisterDTO registerDTO) {
        log.info("用户注册请求: 用户名={}, 邮箱={}", registerDTO.getUsername(), registerDTO.getEmail());

        try {
            // 1. 验证邮箱验证码
            VerificationRequestDTO verifyDto = new VerificationRequestDTO();
            verifyDto.setEmail(registerDTO.getEmail());
            verifyDto.setCode(registerDTO.getCode());
            verifyDto.setType(VerificationCodeType.REGISTRATION.getValue());

            boolean isCodeValid = verificationCodeService.verifyCode(verifyDto);
            if (!isCodeValid) {
                log.warn("注册验证码无效或已过期: 邮箱={}, 验证码={}", registerDTO.getEmail(), registerDTO.getCode());
                return Result.fail(ResultCode.VERIFICATION_CODE_ERROR);
            }

            // 2. 调用用户服务进行注册
            Result<UserVO> result = userService.register(registerDTO);
            
            if (result.getCode() != 200) {
                log.warn("用户注册失败: {}", result.getMsg());
                return result;
            }
            
            log.info("用户注册成功: 用户名={}", registerDTO.getUsername());
            return result;
        } catch (Exception e) {
            log.error("用户注册发生异常: {}", e.getMessage(), e);
            return Result.fail(ResultCode.SYSTEM_ERROR.getCode(), "注册处理过程中发生错误: " + e.getMessage(), null);
        }
    }

    /**
     * 查询当前登录的用户信息接口
     *
     * @return 当前登录用户的用户信息
     */
    @Log(description = "查询当前登录用户信息", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "查询当前登录的用户信息")
    @GetMapping("/getCurrentUser")
    public Result<UserVO> current() {
        return Result.success(userService.getCurrentUser());
    }

    /**
     * 修改当前登录的用户信息接口
     *
     * @param updateDTO 包含允许用户修改的字段的DTO
     * @return 更新后的用户信息
     */
    @Log(description = "修改当前登录用户信息", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "修改当前登录的用户信息")
    @PutMapping("/updateLoginUser")
    public Result<UserVO> updateLoginUser(@Valid @RequestBody UserProfileUpdateDTO updateDTO) {
        UserVO userVO = userService.updateLoginUser(updateDTO);
        return Result.success(userVO);
    }

    /**
     * 分页查询用户信息接口（适用于后台管理系统）
     *
     * @param userQuery 用户查询条件，包含分页信息
     * @return 分页查询结果，包含用户信息列表
     */
    @Log(description = "分页查询用户信息", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "分页查询用户信息-后台管理系统")
    @GetMapping("/userPage")
    public Result<PageResult<UserVO>> userPage(UserQuery userQuery) {
        PageResult<UserVO> userVOPageResult = userService.userPage(userQuery);
        return Result.success(userVOPageResult);
    }

    /**
     * 修改用户状态接口
     *
     * @param user 用户实体，包含更新后的状态信息
     * @return 更新后的用户信息
     */
    @Log(description = "修改用户状态", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "修改用户状态")
    @PutMapping("/updateUserStatus")
    public Result<UserVO> updateStatus(User user) {
        return Result.success(userService.updateStatus(user));
    }

    /**
     * 批量删除用户接口（适用于后台管理系统）
     *
     * @param ids 要删除的用户ID列表
     * @return 删除结果，表示操作成功
     */
    @Log(description = "批量删除用户", operationType = OperationTypeEnum.DELETE)
    @Operation(summary = "批量删除用户-后台管理系统")
    @DeleteMapping("/deleteBatchUsers/{ids}")
    public Result<String> deleteBatch(@PathVariable @RequestBody List<String> ids) {
        userService.deleteBatch(ids);
        return Result.success();
    }

    /**
     * 修改用户角色接口（适用于后台管理系统）
     *
     * @param userRole 用户角色实体，包含用户ID和角色信息
     * @return 更新后的用户信息
     */
    @Log(description = "修改用户角色", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "修改用户角色-后台管理系统")
    @PutMapping("/updateUserRole")
    public Result<UserVO> updateUserRole(@RequestBody UserRole userRole) {
        UserVO userVO = userService.updateRole(userRole);
        return Result.success(userVO);
    }

    /**
     * 根据ID查询用户信息接口
     *
     * @param userId 用户ID
     * @return 用户信息
     */
    @Log(description = "根据ID查询用户信息", operationType = OperationTypeEnum.QUERY)
    @Operation(summary = "根据ID查询用户信息")
    @GetMapping("/getUserById")
    public Result<UserVO> getUserById(@RequestParam("userId") String userId) {
        log.info("根据用户id获取用户信息：{}", userId);
        return Result.success(userService.getUserById(userId));
    }

    /**
     * 更新用户已用存储空间接口
     *
     * @param userId 用户ID
     * @param fileSize 文件大小（增量，可以为负数）
     * @return 操作结果
     */
    @Log(description = "更新用户存储空间使用情况", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "更新用户已用存储空间")
    @PutMapping("/updateStorageUsed")
    public Result<Void> updateStorageUsed(@RequestParam("userId") String userId, @RequestParam("fileSize") long fileSize) {
        log.info("更新用户 {} 的存储空间，增量: {}", userId, fileSize);
        boolean success = userService.updateStorageUsed(userId, fileSize);
        return success ? Result.success() : Result.fail(ResultCode.FAIL);
    }

    /**
     * 重置用户密码接口
     *
     * @param user 用户实体，包含需要重置密码的用户信息
     * @return 重置密码结果，成功消息
     */
    @Log(description = "重置用户密码", operationType = OperationTypeEnum.UPDATE)
    @Operation(summary = "重置用户密码")
    @PutMapping("/resetUserPassword")
    public Result<String> resetPassword(@RequestBody User user) {
        userService.resetPassword(user);
        return Result.success("密码重置成功");
    }
}
